﻿using System;
using System.Collections.Generic;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Windows;
using System.Windows.Input;
using Sinacor.Infra.UI.Controls;
using Sinacor.UI.Bovespa.Ordens.Presenter;
using Sinacor.Infra.UI.Controls.SmartClient;
using PSE.Framework.UI.Resources;
using System.Windows.Controls;
using Sinacor.UI.Bovespa.Clientes.View.SmartClient;
using System.Windows.Media;
using Sinacor.UI.Bovespa.Ordens.Model.Enum;
using Sinacor.Infra.UI.Common;


namespace Sinacor.UI.Bovespa.Ordens.View.SmartClient
{
    public partial class DistribuicaoOrdemLote : SinacorWindow, IDistribuicaoOrdemLoteView
    {
        /// <summary>
        /// Property com a presenter da view
        /// </summary>
        public DistribuicaoOrdemLotePresenter Presenter { get; set; }
        private SinacorPopup popup = new SinacorPopup();

        private SinacorPopup popUpDiscricionarias = new SinacorPopup();
        private SinacorPopup popUpNaoDiscricionarias = new SinacorPopup();
        private SinacorPopup popUpTodas = new SinacorPopup();

        private SinacorListBox lotesListBox = null;

        private SinacorListBox lotesListBoxDiscricionarias = null;
        private SinacorListBox lotesListBoxNaoDiscricionarias = null;
        private SinacorListBox lotesListBoxTodas = null;

        private enum _TipoAgrupamento
        {
            Nenhum,
            Padrao,
            Operador,
            Ordem,
            AdminConcorr,
            OperPOP
        }
        private _TipoAgrupamento tipoAgrupamento = _TipoAgrupamento.Nenhum;
        private enum _TipoDiscricionaria
        {
            Nenhuma,
            Todas,
            Discricionarias,
            NaoDiscricionarias
        }
        private _TipoDiscricionaria tipoDiscricionaria = _TipoDiscricionaria.Nenhuma;
        private bool modulePlusLicense = false;
        public bool ModulePlusLicense
        {
            get { return this.modulePlusLicense; }
        }
        private bool _acessoCancelamentoDistribuicao = false;

        #region Variáveis de controle de estado/processamento

        private bool _cancelamentoValido = false;
        private bool _consultaValida = false;

        #endregion

        #region Eventos

        private void DistribuicaoOrdemLote_AfterInitialize(object sender, RoutedEventArgs e)
        {
            this.Habilitar(false);

            // nao permitir selecao multipla na grade se sistema nao estiver licenciado para Kernel+
            modulePlusLicense = this.CheckModulePlusLicense();



            //this.ordensExpander.IsExpanded = false;
            this.ordensExpanderDiscricionarias.IsExpanded = false;
            this.ordensExpanderNaoDiscricionarias.IsExpanded = false;
            this.ordensExpanderTodas.IsExpanded = false;

            this.Presenter.ConsultarCalendario();

            if (Presenter.CalendarioModelCollection != null && Presenter.CalendarioModelCollection.Count != 0)
                cmbData.SelectedIndex = 0;

            //VERIFICAR O TIPO DE PERMISSÃO PARA O USUÁRIO DA TELA.
            Presenter.HabilitaControlesConsulta();

            this.Habilitar(true);
        }

        void popup_LostFocus(object sender, RoutedEventArgs e)
        {
            MostrarPopUp(false);
        }

        // metodo usado pelo evento Click do botao de pesquisa
        private void btnPesquisar_Click(object sender, RoutedEventArgs e)
        {
            //MessageBox.Show(((SinacorTabItem)tabGrupoLotes.Items.CurrentItem).Name);

            this.AtualizaGrids(false);
        }

        private void lotesDataGrid_SelectionChanged(object sender, SelectionChangedEventArgs e){}

        private void lotesDataGrid_BufferedSelectionChanged(object sender, BufferedEventArgs<SelectionChangedEventArgs> e)
        {
            #region Habilitação do item do menu de contexto "Distribuir"

            this.ClearServiceErrors();
            ModelCollection<Model.Ordem> lotes = GetGridSelectedItems((SinacorDataGrid)sender);

            //CRIO UM OBJETO SINACORDATAGRID QUE RECEBE O GRID CHAMADOR DO MÉTODO
            SinacorDataGrid lotesDataGrid = (SinacorDataGrid)sender;

            if (lotes != null && lotes.Count > 0)
            {
                //PRIMEIRO DE TUDO, HABILITO O CONTROLE
                Presenter.HabilitarDistribuicao(true);

                //SE A SELEÇÃO FOR MÚLTIPLA, VERIFICAR O TIPO DE AGRUPAMENTO. NÃO PODE SER OPERAÇÕES POP OU ADMINISTRADO CONCORRENTE
                if (lotesDataGrid.SelectedItems.Count > 1 && (rdbAdmConc.IsChecked == true || rdbOpPOP.IsChecked == true))
                {
                    Presenter.HabilitarDistribuicao(false);
                }

                //PRIMEIRO VALIDO O PRIMEIRO LOTE DA SELEÇÃO (NO LOOP ABAIXO EU SÓ COMPARO OS SUBSEQUENTES COM O PRIMEIRO
                //Se houver mais de um lote selecionado, quantidade digitada e perc. digitado deve ser 0
                if (lotesDataGrid.SelectedItems.Count > 1 && (lotes[0].QuantidadeDigitada > 0 || lotes[0].PercentualDigitado > 0))
                {
                    Presenter.HabilitarDistribuicao(false);
                }
                if (lotes[0].QuantidadeCasada == null || lotes[0].QuantidadeCasada.Value == 0)
                {
                    Presenter.HabilitarDistribuicao(false);
                }


                //O LOOP ABAIXO SÓ SERÁ EXECUTADO CASO HAJAM MAIS DE UMA LINHA SELECIONADA
                for (int i = 1; i < lotes.Count; i++)
                {
                    if (lotes[i].QuantidadeDigitada > 0 || lotes[i].PercentualDigitado > 0)
                    {
                        Presenter.HabilitarDistribuicao(false);
                        break;
                    }
                    if (lotes[i].QuantidadeCasada == null || lotes[i].QuantidadeCasada.Value == 0)
                    {
                        Presenter.HabilitarDistribuicao(false);
                        break;
                    }
                    if (lotes[i].ApelidoCliente != lotes[0].ApelidoCliente || lotes[i].Discricionaria != lotes[0].Discricionaria || lotes[i].CodigoNegocio != lotes[0].CodigoNegocio)
                    {
                        Presenter.HabilitarDistribuicao(false);
                        break;
                    }
                }
            }
            else
            {
                Presenter.HabilitarDistribuicao(false);
            }
            #endregion

            #region Habilitação do item do menu de contexto "Cancelar Distribuição"
            //SÓ FAÇO VERIFICAÇÃO DE STATUS DA SELEÇÃO SE O USUÁRIO TIVER ACESO A CANCELAMENTO
            if (this._acessoCancelamentoDistribuicao)
            {
                //HABILITO/DESABILITO MENU DE CONTEXTO DE CANCELAMENTO, CONFORME EXISTEM ITENS SELECIONADOS
                Presenter.HabilitaCancelamentoMultiplo(lotesDataGrid.SelectedItems != null && lotesDataGrid.SelectedItems.Count > 0);

                foreach (Model.Ordem itemLote in lotesDataGrid.SelectedItems)
                {
                    if (Presenter.VerificarDistribuicaoOrdem(itemLote) == StatusDistribuicaoOrdem.NaoDistribuida)
                    {
                        Presenter.HabilitaCancelamentoMultiplo(false);
                    }
                }
            }
            else //USUÁRIO NÃO TEM PERMISSÃO DE CANCELAMENTO DE DISTRIBUIÇÃO
            {
                Presenter.HabilitaCancelamentoMultiplo(false);
            }
            #endregion

            //SE O AGRUPAMENTO FOR ADMINISTRADO CONCORRENTE OU OPERAÇÕES POP, SAIR DO MÉTODO
            if (rdbAdmConc.IsChecked == true || rdbOpPOP.IsChecked == true) return;

            //SE MAIS DE UM LOTE ESTIVER SELECIONADO, SAIR DO MÉTODO
            if (lotesDataGrid.SelectedItems.Count > 1) return;

            // se nao possui licenca para o modulo plus, permite selecionar apenas um item por vez no grid
            //if (!modulePlusLicense)
            //    SingleSelect(sender);

            //Model.Ordem item = (Model.Ordem)lotesDataGrid.SelectedItem;
            //item.NumeroConjunto = 666;
            //this.ApresentarOrdemDistribuicao();

            this.Habilitar(false);
            this.AtualizarGridOrdens((SinacorDataGrid)sender);

            lotesDataGrid.Focus();

            this.Habilitar(true);

            //Presenter.OrdemDistribuicaoModelCollection[0].NumeroConjunto = 999;
            //this.ApresentarOrdemDistribuicao();
        }

        // metodo executado toda vez que o usuario modifica os criterios e ja existe alguma pesquisa sendo mostrada
        private void grupo_Click(object sender, RoutedEventArgs e)
        {
            bool mudouCriterioPesquisa = false;
            _TipoAgrupamento tipoAgrupamentoAnterior;

            switch (((SinacorRadioButton)sender).Name)
            {
                case "rdbPadrao":
                    if (this.tipoAgrupamento != _TipoAgrupamento.Padrao)
                    {
                        mudouCriterioPesquisa = true;
                        this.tipoAgrupamento = _TipoAgrupamento.Padrao;
                    }
                    break;
                case "rdbOperador":
                    if (this.tipoAgrupamento != _TipoAgrupamento.Operador)
                    {
                        mudouCriterioPesquisa = true;
                        this.tipoAgrupamento = _TipoAgrupamento.Operador;
                    }
                    break;
                case "rdbOrdem":
                    if (this.tipoAgrupamento != _TipoAgrupamento.Ordem)
                    {
                        mudouCriterioPesquisa = true;
                        this.tipoAgrupamento = _TipoAgrupamento.Ordem;
                    }
                    break;
                case "rdbAdmConc":
                    if (this.tipoAgrupamento != _TipoAgrupamento.AdminConcorr)
                    {
                        //GUARDO O AGRUPAMENTO ANTERIOR
                        tipoAgrupamentoAnterior = this.tipoAgrupamento;
                        //DEFINO O AGRUPAMENTO ATUAL
                        this.tipoAgrupamento = _TipoAgrupamento.AdminConcorr;
                        //VERIFICO SE A DATA DO PREGÃO ESTÁ EM CONFORMIDADE COM O AGRUPAMENTO
                        if (((Model.Calendario)cmbData.SelectedItem).DataPregao.ToShortDateString() != DateTime.Now.ToShortDateString())
                            Presenter.ValidaDataAgrupamento();

                        //VERIFICO AO FINAL SE O AGRUPAMENTO SELECIONADO É O MESMO DO ANTERIOR, CASO CONTRARIO, COMANDO A LIMPEZA
                        if (this.tipoAgrupamento != tipoAgrupamentoAnterior)
                            mudouCriterioPesquisa = true;
                    }
                    break;
                case "rdbOpPOP":
                    if (this.tipoAgrupamento != _TipoAgrupamento.OperPOP)
                    {
                        mudouCriterioPesquisa = true;
                        this.tipoAgrupamento = _TipoAgrupamento.OperPOP;
                    }
                    break;
                //case "rdbTodas":
                //    if (this.tipoDiscricionaria != _TipoDiscricionaria.Todas)
                //    {
                //        mudouCriterioPesquisa = true;
                //        this.tipoDiscricionaria = _TipoDiscricionaria.Todas;
                //    }
                //    break;
                //case "rdbDiscr":
                //    if (this.tipoDiscricionaria != _TipoDiscricionaria.Discricionarias)
                //    {
                //        mudouCriterioPesquisa = true;
                //        this.tipoDiscricionaria = _TipoDiscricionaria.Discricionarias;
                //    }
                //    break;
                //case "rdbNaoDiscr":
                //    if (this.tipoDiscricionaria != _TipoDiscricionaria.NaoDiscricionarias)
                //    {
                //        mudouCriterioPesquisa = true;
                //        this.tipoDiscricionaria = _TipoDiscricionaria.NaoDiscricionarias;
                //    }
                //    break;
            }

            //CASO O CRITÉRIO DE PESQUISA TENHA SIDO MODIFICADO E A MODEL DE LOTES ESTEJA PREENCHIDA, LIMPO A TELA
            if (this.Presenter.LotesTodasModelCollection != null && mudouCriterioPesquisa)
                this.Presenter.Limpar();

            //if (this.Presenter.OrdemDistribuicaoModelCollection != null && mudouCriterioPesquisa)
            //    this.Presenter.Limpar();

            ////UM MONTE DE IF PRA SABER SE MUDOU O CRITERIO DE PESQUISA
            //if ((SinacorRadioButton)sender == rdbAdmConc && this.tipoAgrupamento != _TipoAgrupamento.AdminConcorr)
            //{
            //    mudouCriterioPesquisa = true;
            //}
            //if ((SinacorRadioButton)sender == rdbOperador && this.tipoAgrupamento != _TipoAgrupamento.Operador)
            //{
            //    mudouCriterioPesquisa = true;
            //}
            //if ((SinacorRadioButton)sender == rdbPadrao && this.tipoAgrupamento != _TipoAgrupamento.Pardao)
            //{
            //    mudouCriterioPesquisa = true;
            //}
            //if ((SinacorRadioButton)sender == rdbOrdem && this.tipoAgrupamento != _TipoAgrupamento.Ordem)
            //{
            //    mudouCriterioPesquisa = true;
            //}
            //if ((SinacorRadioButton)sender == rdbOpPOP && this.tipoAgrupamento != _TipoAgrupamento.OperPOP)
            //{
            //    mudouCriterioPesquisa = true;
            //}
            //if ((SinacorRadioButton)sender == rdbTodas && this.tipoDiscricionaria != _TipoDiscricionaria.Todas)
            //{
            //    mudouCriterioPesquisa = true;
            //}
            //if ((SinacorRadioButton)sender == rdbDiscr && this.tipoDiscricionaria != _TipoDiscricionaria.Discricionarias)
            //{
            //    mudouCriterioPesquisa = true;
            //}
            //if ((SinacorRadioButton)sender == rdbNaoDiscr && this.tipoDiscricionaria != _TipoDiscricionaria.NaoDiscricionarias)
            //{
            //    mudouCriterioPesquisa = true;
            //}

            //if (((SinacorRadioButton)sender) == rdbAdmConc && this.tipoAgrupamento != _TipoAgrupamento.AdminConcorr )
            //{
            //    this.tipoAgrupamento = _TipoAgrupamento.AdminConcorr;

            //    if (((Model.Calendario)cmbData.SelectedItem).DataPregao.ToShortDateString() != DateTime.Now.ToShortDateString())
            //        Presenter.ValidaDataAgrupamento();
            //}

            //if (rdbAdmConc.IsChecked == true && ((Model.Calendario)cmbData.SelectedItem).DataPregao.ToShortDateString() != DateTime.Now.ToShortDateString())
            //{
            //    Presenter.ValidaDataAgrupamento();
            //}
        }

        private void cmbData_DropDownClosed(object sender, EventArgs e)
        {
            //Presenter.Limpar();            
        }

        private void btnConsultarCliente_Click(object sender, RoutedEventArgs e)
        {
            PesquisaClientes pesquisaCliente = new PesquisaClientes();
            Sinacor.UI.Bovespa.Clientes.Model.PesquisaCliente filtro = new Sinacor.UI.Bovespa.Clientes.Model.PesquisaCliente();

            try
            {
                filtro.Apelido = txtCliente.Text;

                pesquisaCliente.Owner = this;
                pesquisaCliente.SetMenuHeader("Bovespa.Clientes.Label.PesquisaClientesMenuHeader");
                pesquisaCliente.CarregaParametros(Sinacor.UI.Bovespa.Clientes.Model.Enum.JanelaChamada.DistribuicaoOrdemLote, filtro);
                pesquisaCliente.ShowDialog();

                if (pesquisaCliente.PesquisaClienteModel.Codigo > 0)
                {
                    Presenter.OrdemDistribuicaoModel.ApelidoCliente = pesquisaCliente.PesquisaClienteModel.Apelido;
                    txtCliente.UpdateTarget(SinacorTextBox.TextProperty);
                }
            }
            catch
            {
                InformarErro("Bovespa.Ordens.Message.PesquisaSemRetorno");
            }
            finally
            {
                pesquisaCliente.Hide();
                pesquisaCliente = null;
            }
        }

        private void SinacorWindow_StateChanged(object sender, EventArgs e)
        {
            MostrarPopUp(false);
        }

        private void SinacorWindow_MouseLeave(object sender, MouseEventArgs e)
        {
            MostrarPopUp(false);
        }

        private void SinacorWindow_Closed(object sender, EventArgs e)
        {
            MostrarPopUp(false);
        }

        private void txtAtivo_LostFocus(object sender, RoutedEventArgs e)
        {
            //SinacorTextBox textBox = (SinacorTextBox)sender;

            //if (Presenter.OrdemDistribuicaoModel.Titulo != null)
            //    Presenter.OrdemDistribuicaoModel.Titulo = Presenter.OrdemDistribuicaoModel.Titulo.ToUpper();
            //else
            //    Presenter.OrdemDistribuicaoModel.Titulo = string.Empty;

            //textBox.UpdateTarget(SinacorTextBox.TextProperty);
        }

        private void ordensDataGrid_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            //GRID DE ORDENS: PODE SER ordensDiscricionariasDataGrid, ordensNaoDiscricionariasDataGrid OU ordensTodasDataGrid
            SinacorDataGrid ordensDataGrid = (SinacorDataGrid)sender;

            //CRIO OS OBJETOS "CORINGAS" DE LOTES E PRECO MÉDIO
            SinacorDataGrid precoMedioDataGrid = new SinacorDataGrid();
            SinacorDataGrid lotesDataGrid = new SinacorDataGrid();

            //ARMAZENO O NOME DA GRID DE ORDENS CHAMADORA, PARA CONSULTA AO LONGO DO MÉTODO
            string gridChamadora = ((SinacorDataGrid)sender).Name;

            switch (gridChamadora)
            {
                case "ordensDiscricionariasDataGrid":
                    precoMedioDataGrid = precoMedioDiscricionariasDataGrid;
                    lotesDataGrid = lotesDataGridDiscricionarias;
                    break;
                case "ordensNaoDiscricionariasDataGrid":
                    precoMedioDataGrid = precoMedioNaoDiscricionariasDataGrid;
                    lotesDataGrid = lotesDataGridNaoDiscricionarias;
                    break;
                case "ordensTodasDataGrid":
                    precoMedioDataGrid = precoMedioTodasDataGrid;
                    lotesDataGrid = lotesDataGridTodas;
                    break;
            }

            //Se não houver item selecionado na grid de lotes, abandonar o método
            if (lotesDataGrid.Items != null && lotesDataGrid.Items.Count == 0)
            {
                return;
            }

            //CASO A GRID DE ORDEM NÃO TENHA NENHUM ITEM SELECIONADO, REFAZ A CONSULTA
            if (ordensDataGrid.SelectedItem == null)
            {
                this.Habilitar(false);

                Presenter.LoteVinculadoModelCollection.Clear();
                Model.Ordem loteSelecionado = (Model.Ordem)lotesDataGrid.SelectedItems[0];
                Model.Parameter.ConsultarLoteVinculado consultaLoteVinculado = new Model.Parameter.ConsultarLoteVinculado();

                
                consultaLoteVinculado.ApelidoCliente = loteSelecionado.ApelidoCliente;
                consultaLoteVinculado.CodigoCasamento = loteSelecionado.CodigoCasamento;
                consultaLoteVinculado.CodigoCliente = null;
                consultaLoteVinculado.CodigoNegocio = loteSelecionado.Titulo;
                consultaLoteVinculado.DataPregao = ((Model.Calendario)cmbData.SelectedItem).DataPregao;
                consultaLoteVinculado.Discricionaria = loteSelecionado.Discricionaria;
                consultaLoteVinculado.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)loteSelecionado.NaturezaOperacao;
                consultaLoteVinculado.NumeroConjunto = loteSelecionado.NumeroConjunto.Value;
                consultaLoteVinculado.PrazoTermo = loteSelecionado.PrazoTermo;

                //Presenter.ConsultarLoteVinculado(consultaLoteVinculado);
                //CHAMO A CONSULTA ESPECÍFICA
                switch (gridChamadora)
                {
                    case "ordensDiscricionariasDataGrid":
                        Presenter.ConsultarLoteVinculadoDiscricionarias(consultaLoteVinculado);
                        break;
                    case "ordensNaoDiscricionariasDataGrid":
                        Presenter.ConsultarLoteVinculadoNaoDiscricionarias(consultaLoteVinculado);
                        break;
                    case "ordensTodasDataGrid":
                        Presenter.ConsultarLoteVinculadoTodas(consultaLoteVinculado);
                        break;
                }

                ApresentarLoteVinculado();
                this.Habilitar(true);
            }

            //ALGORITMO ALTERNATIVO
            #region Algoritmo Alternativo
            //if (ordensDataGrid.SelectedItem == null)
            //{
            //    int nrConj = 0;
            //    List<Model.Ordem> ordensEncontradas = new List<Sinacor.UI.Bovespa.Ordens.Model.Ordem>();

            //    //PERCORRO A GRID DE PREÇO MÉDIO
            //    for (int i = 0; i < precoMedioDataGrid.Items.Count; i++)
            //    {
            //        Model.LoteOrdem itemPrecoMedio = (Model.LoteOrdem)precoMedioDataGrid.Items[i];

            //        //GUARDO O NÚMERO DO LOTE
            //        nrConj = itemPrecoMedio.NumeroConjunto;

            //        if (nrConj > 0)
            //        {
            //            //PROCURO O NÚMERO DO LOTE NA GRID DE ORDENS
            //            foreach (Model.Ordem itemOrdem in ordensDataGrid.Items)
            //            {
            //                if (itemOrdem.NumeroConjunto == nrConj)
            //                {
            //                    ordensEncontradas.Add(itemOrdem);
            //                }
            //            }
            //            //SE ENCONTREI ALGUMA ORDEM COM ESTE NÚMERO DE LOTE
            //            if (ordensEncontradas.Count > 0)
            //            {
            //                //PEÇO À PRESENTER QUE CALCULE O PREÇO MÉDIO
            //                itemPrecoMedio.PrecoMedio = Presenter.CalcularPrecoMedio(ordensEncontradas);

            //            }//CASO CONTRÁRIO, PROCURO O ITEM ENTRE OS LOTES
            //            else
            //            {
            //                foreach (Model.Ordem itemLote in lotesDataGrid.Items)
            //                {
            //                    if (itemLote.NumeroConjunto == nrConj)
            //                    {
            //                        itemPrecoMedio.PrecoMedio = itemLote.PrecoMedio == null ? 0 : (decimal)itemLote.PrecoMedio;
            //                        break;
            //                    }
            //                }
            //            }
            //        }
            //        else
            //        {
            //            //TODO: VERIFICAR O QUE OCORRE QUANDO O "NOVO LOTE" ESTIVER EM PRIMEIRO
            //            itemPrecoMedio.PrecoMedio = 0;
            //        }
            //    }
            //}
            #endregion

            // se grid estiver vazio, nao efetua nenhum processamento extra.            
            if (ordensDataGrid.SelectedItem == null || precoMedioDataGrid.Items.Count < 1)
                return;


            //A EXECUÇÃO SÓ ATINGE ESTE PONTO ALGUMA LINHA ESTIVER SELECIONADA.
            Model.Ordem ordemAtual = (Model.Ordem)lotesDataGrid.SelectedItem;
            Model.LoteOrdem novoLoteOrdem = null;
            int index = 0; //ÍNDICE PARA INICIAR A VARREDURA DA GRID PREÇO MÉDIO PARA CALCULAR P.M. DE OUTROS LOTES (SE HOUVEREM)

            //SE O NÚMERO DO LOTE FOR DIFERENTE DE ZERO, 
            //ENTÃO HAVERÁ LOTE NA PRIMEIRA LINHA.
            if (ordemAtual.NumeroConjunto != 0)
            {
                //CRIO UMA MODEL TEMPORÁRIA COM A LINHA "NOVO LOTE" NA GRID
                novoLoteOrdem = (Model.LoteOrdem)precoMedioDataGrid.Items[1];
                index = 2; //INDICE 0 - LOTE ATUAL, INDICE 1 - NOVO LOTE

                // recalcular preco do lote atual
                Model.LoteOrdem atualLoteOrdem = (Model.LoteOrdem)precoMedioDataGrid.Items[0];
                List<Model.Ordem> ordensNaoSelecionadas = new List<Sinacor.UI.Bovespa.Ordens.Model.Ordem>();

                //MONTO UMA MODEL COM AS ORDENS NÃO SELECIONADAS
                foreach (Model.Ordem o in ordensDataGrid.Items)
                {
                    if (!ordensDataGrid.SelectedItems.Contains(o))
                        ordensNaoSelecionadas.Add(o);
                }
                //CALCULO O PREÇO MÉDIO DO LOTE ATUAL
                atualLoteOrdem.PrecoMedio = Presenter.CalcularPrecoMedio(ordensNaoSelecionadas);
            }
            else //SE FOR ZERO, A PRIMEIRA LINHA DA GRID PREÇO MÉDIO SERÁ NOVO LOTE
            {
                //CRIO UMA MODEL TEMPORÁRIA COM A LINHA "NOVO LOTE" NA GRID
                novoLoteOrdem = (Model.LoteOrdem)precoMedioDataGrid.Items[0];
                index = 1; //INDICE 0 - NOVO LOTE
            }

            // calcular preco medio de um novo lote
            novoLoteOrdem.PrecoMedio = Presenter.CalcularPrecoMedio(ordensDataGrid.SelectedItems);

            // calcular preco medio dos lotes listados para troca, se houver algum
            List<Model.Ordem> ordensTroca = new List<Sinacor.UI.Bovespa.Ordens.Model.Ordem>(GetGridSelectedItems(ordensDataGrid));
            Model.Ordem ordemFake = new Model.Ordem();

            //AGORA PERCORRO A GRID DE PREÇO MÉDIO PARA CADA LOTE QUE HOUVER DEPOIS DO LOTE ATUAL (SE HOUVER) E NOVO LOTE
            for (int i = index; i < precoMedioDataGrid.Items.Count; i++)
            {
                Model.LoteOrdem loteOrdem = (Model.LoteOrdem)precoMedioDataGrid.Items[i];

                //AGORA VOU BUSCAR O PREÇO MÉDIO DO LOTE NA GRID DE LOTES
                loteOrdem.PrecoMedio = ObterPrecoMedioLote(lotesDataGrid, loteOrdem.NumeroConjunto);

                //cria uma ordem falsa com preco medio e quantidade, insere na listagem e recalcula o preco medio
                ordemFake.QuantidadeCasada = loteOrdem.QuantidadeCasada;
                ordemFake.PrecoMedio = loteOrdem.PrecoMedio;
                ordensTroca.Add(ordemFake);
                loteOrdem.PrecoMedio = Presenter.CalcularPrecoMedio(ordensTroca);
                ordensTroca.Remove(ordemFake);
            }

            this.ApresentarLoteVinculado();
            this.Habilitar(true);
        }

        // permitir selecionar apenas um item por vez em um dado grid
        private void SingleSelect(object sender, SelectionChangedEventArgs e)
        {
            SinacorDataGrid grid = (SinacorDataGrid)sender;

            // se nao houve itens selecionados, nao faz nada
            if (grid.SelectedItems == null || grid.SelectedItems.Count == 0)
                return;

            // se houver mais de um item selecionado na lista, prevalecera´ o ultimo
            // e os demais serao descartados
            if (grid.SelectedItems.Count > 1)
            {
                grid.SelectedItem = grid.SelectedItems[grid.SelectedItems.Count - 1];
            }
        }

        // verifica se o item de menu "Trocar de Lote" deve ser desabilitado quando o conteúdo do menu de contexto
        // e´ carregado pela primeira vez
        private void trocarLoteMenuItem_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
            ((SinacorContextMenuItem)sender).IsEnabled = PermitirPopUp();
        }

        // verifica se o item de menu "Trocar de Lote" deve ser desabilitado a cada vez que o menu de contexto surgir
        private void trocarLoteMenuItem_Loaded(object sender, RoutedEventArgs e)
        {
            ((SinacorContextMenuItem)sender).IsEnabled = PermitirPopUp();
        }

        // apresenta Pop-Up para trocar ordens de lote
        private void trocarLoteMenuItem_Click(object sender, RoutedEventArgs e)
        {
            MostrarPopUp(true);
        }

        // troca lista de ordens para um novo lote
        private void lotesListBox_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            SinacorListBox list = (SinacorListBox)sender;

            SinacorTabItem tabSelecionada = (SinacorTabItem)tabGrupoLotes.SelectedItem;
            SinacorDataGrid ordensDataGrid;
            SinacorDataGrid lotesDataGrid;

            if (tabSelecionada == tabDiscricionarias)
            {
                ordensDataGrid = ordensDiscricionariasDataGrid;
                lotesDataGrid = lotesDataGridDiscricionarias;
            }
            else if (tabSelecionada == tabNaoDiscricionarias)
            {
                ordensDataGrid = ordensNaoDiscricionariasDataGrid;
                lotesDataGrid = lotesDataGridNaoDiscricionarias;
            }
            else //tabTodas
            {
                ordensDataGrid = ordensTodasDataGrid;
                lotesDataGrid = lotesDataGridTodas;
            }

            if (list.SelectedItem != null)
            {
                int numeroLoteDestino = ((Model.LoteOrdem)list.SelectedItem).NumeroConjunto;
                this.Habilitar(false);


                if (!Presenter.TrocarLoteOrdem(GetGridSelectedItems(ordensDataGrid), numeroLoteDestino))
                {
                    //InformarErro("Bovespa.Ordens.Message.ErroTrocarLote");
                    return;
                }
                
                AtualizaGrids(false);


                if (chkAtualizarGradeLotes.IsChecked != true)
                {
                    AtualizarGridOrdens(lotesDataGrid);
                }

                Informar("Bovespa.Ordens.Message.LoteTrocado");
            }
        }

        // criar um novo lote 
        private void criarLoteMenuItem_Click(object sender, RoutedEventArgs e)
        {
            SinacorTabItem tabSelecionada = (SinacorTabItem)tabGrupoLotes.SelectedItem;
            SinacorDataGrid ordensDataGrid;
            SinacorDataGrid lotesDataGrid;
            this.ClearServiceErrors();

            if (tabSelecionada == tabDiscricionarias)
            {
                ordensDataGrid = ordensDiscricionariasDataGrid;
                lotesDataGrid = lotesDataGridDiscricionarias;
            }
            else if (tabSelecionada == tabNaoDiscricionarias)
            {
                ordensDataGrid = ordensNaoDiscricionariasDataGrid;
                lotesDataGrid = lotesDataGridNaoDiscricionarias;
            }
            else //tabTodas
            {
                ordensDataGrid = ordensTodasDataGrid;
                lotesDataGrid = lotesDataGridTodas;
            }

            if (ordensDataGrid.SelectedItems == null || ordensDataGrid.SelectedItems.Count == 0)
            {
                InformarErro("Bovespa.Ordens.Message.ObrigatorioSelecionarOrdens");
                return;
            }

            ModelCollection<Model.Ordem> ordens = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem>((IEnumerable)ordensDataGrid.SelectedItems);
            int numeroNovoLote = this.CriarNovoLote(ordens);

            if (numeroNovoLote != 0)
            {
                //Foram selecionados todas ordens do lote e foi gerado um novo lote
                if (ordensDataGrid.SelectedItems.Count == ordensDataGrid.Items.Count)
                {
                    ((Model.Ordem)lotesDataGrid.SelectedItem).NumeroConjunto = numeroNovoLote;

                    this.Habilitar(false);
                    this.AtualizarGridOrdens(lotesDataGrid);
                    this.Habilitar(true);

                    SinacorMessageBox.Show(
                        string.Format(novoLoteResourceString, numeroNovoLote),
                        SinacorMessageBoxImage.Information
                    );

                    AtualizaGrids(true);
                }
                else
                {
                    int loteSelecionado = ((Model.Ordem)lotesDataGrid.SelectedItem).NumeroConjunto.Value;

                    AtualizaGrids(false);

                    ModelCollection<Model.Ordem> aux = (ModelCollection<Model.Ordem>)lotesDataGrid.ItemsSource;

                    foreach (Model.Ordem ordemAux in aux)
                    {
                        if (ordemAux.NumeroConjunto == loteSelecionado)
                        {
                            lotesDataGrid.SelectedItem = ordemAux;
                            break;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// verifica se o item de menu "Criar Novo Lote" deve ser desabilitado quando o conteúdo do menu de contexto
        /// e´ carregado pela primeira vez
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void criarLoteMenuItem_Loaded(object sender, RoutedEventArgs e)
        {
            ((SinacorContextMenuItem)sender).IsEnabled = PermitirCriarLote();
        }

        private void criarLoteMenuItem_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
            ((SinacorContextMenuItem)sender).IsEnabled = PermitirCriarLote();
            ((SinacorContextMenuItem)sender).IsEnabled = false;
        }

        private void btnConsultarAtivo_Click(object sender, RoutedEventArgs e)
        {
            if (cmbData.SelectedItem == null)
            {
                InformarErro("Bovespa.Ordens.Message.DataPregaoInvalida");
                return;
            }

            this.Habilitar(false);

            Model.Titulo modelTitulo = new Model.Titulo();
            modelTitulo.Codigo = txtAtivo.Text;
            modelTitulo.Mercado = null;
            modelTitulo.DataPregao = ((Model.Calendario)cmbData.SelectedItem).DataPregao;

            PesquisaTitulo pesquisaTitulo = new PesquisaTitulo();
            pesquisaTitulo.CarregarParametros(modelTitulo, TelaChamadora.CadastramentoNegocio);
            pesquisaTitulo.Owner = this;
            pesquisaTitulo.SetMenuHeader("Bovespa.Ordens.Label.PesquisaTitulo");
            pesquisaTitulo.ShowDialog();

            if (pesquisaTitulo.TituloEscolhido != null)
            {
                Presenter.OrdemDistribuicaoModel.Titulo = pesquisaTitulo.TituloEscolhido.Codigo;
                txtAtivo.UpdateTarget(SinacorTextBox.TextProperty);
            }

            this.Habilitar(true);
        }

        /// <summary>
        /// abrir tela de "Distribuição de Ordens - Digitação" caso o usuário dê duplo clique no grid
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void lotesDataGrid_ConfirmSelection(object sender, ItemEventArgs e)
        {
            this.Habilitar(false);
            try
            {
                this.EnviarLotesDigitacao((SinacorDataGrid)sender);
            }
            catch
            {
                InformarErro("Bovespa.Ordens.ExceptionMessage.ErroEnviarLoteDigitacao");
            }
            finally
            {
                this.Habilitar(true);
            }
        }

        /// <summary>
        /// - Altera cor da linha para:
        ///    AZUL
        ///        Se a quantidade digitada é igual à quantidade casada 
        ///        OU 
        ///        o percentual digitado é igual a 100% (cem por cento), 
        ///        para o pregão indicado no campo Data Pregão.
        ///    VERMELHO
        ///        Se ordem não está distribuída, ou seja, a quantidade digitada 
        ///        ou o percentual digitado é igual a 0 (zero), 
        ///        para o pregão indicado no campo Data Pregão.
        ///    VERDE
        ///        Se a quantidade digitada é maior que 0 (zero) e menor que 
        ///        a quantidade casada 
        ///        OU
        ///        o percentual digitado é maior que 0 (zero) e menor que 
        ///        100% (cem por cento), para o pregão indicado no campo 
        ///        Data Pregão.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void lotesDataGrid_ApplyingStyle(object sender, ApplyStyleEventArgs e)
        {
            if (e.ItemInfo.Item == null)
                return;

            if (e.OriginalSource is BaseRow)
            {
                switch (Presenter.VerificarDistribuicaoOrdem((Model.Ordem)e.ItemInfo.Item))
                {
                    case StatusDistribuicaoOrdem.ParcialmenteDistribuida:
                        e.Style = BaseRow.GridRowBusiness04; // verde
                        break;

                    case StatusDistribuicaoOrdem.Distribuida:
                        e.Style = BaseRow.GridRowBusiness02; // azul
                        break;

                    default:
                        e.Style = BaseRow.GridRowBusiness06; // vermelho
                        break;
                }
            } // if (e.OriginalSource is BaseRow)}            
        }

        /// <summary>
        /// - Altera cor da linha para:
        ///    AZUL
        ///        Se a quantidade digitada é igual à quantidade casada 
        ///        OU 
        ///        o percentual digitado é igual a 100% (cem por cento), 
        ///        para o pregão indicado no campo Data Pregão.
        ///    VERMELHO
        ///        Se ordem não está distribuída, ou seja, a quantidade digitada 
        ///        ou o percentual digitado é igual a 0 (zero), 
        ///        para o pregão indicado no campo Data Pregão.
        ///    VERDE
        ///        Se a quantidade digitada é maior que 0 (zero) e menor que 
        ///        a quantidade casada 
        ///        OU
        ///        o percentual digitado é maior que 0 (zero) e menor que 
        ///        100% (cem por cento), para o pregão indicado no campo 
        ///        Data Pregão.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void lotesDataGridDiscricionarias_ApplyingStyle(object sender, ApplyStyleEventArgs e)
        {
            if (e.ItemInfo.Item == null)
                return;

            if (e.OriginalSource is BaseRow)
            {
                switch (Presenter.VerificarDistribuicaoOrdem((Model.Ordem)e.ItemInfo.Item))
                {
                    case StatusDistribuicaoOrdem.ParcialmenteDistribuida:
                        e.Style = BaseRow.GridRowBusiness04; // verde
                        break;

                    case StatusDistribuicaoOrdem.Distribuida:
                        e.Style = BaseRow.GridRowBusiness02; // azul
                        break;

                    default:
                        e.Style = BaseRow.GridRowBusiness06; // vermelho
                        break;
                }
            } // if (e.OriginalSource is BaseRow)}
        }

        /// <summary>
        /// - Altera cor da linha para:
        ///    AZUL
        ///        Se a quantidade digitada é igual à quantidade casada 
        ///        OU 
        ///        o percentual digitado é igual a 100% (cem por cento), 
        ///        para o pregão indicado no campo Data Pregão.
        ///    VERMELHO
        ///        Se ordem não está distribuída, ou seja, a quantidade digitada 
        ///        ou o percentual digitado é igual a 0 (zero), 
        ///        para o pregão indicado no campo Data Pregão.
        ///    VERDE
        ///        Se a quantidade digitada é maior que 0 (zero) e menor que 
        ///        a quantidade casada 
        ///        OU
        ///        o percentual digitado é maior que 0 (zero) e menor que 
        ///        100% (cem por cento), para o pregão indicado no campo 
        ///        Data Pregão.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void lotesDataGridNaoDiscricionarias_ApplyingStyle(object sender, ApplyStyleEventArgs e)
        {
            if (e.ItemInfo.Item == null)
                return;

            if (e.OriginalSource is BaseRow)
            {
                switch (Presenter.VerificarDistribuicaoOrdem((Model.Ordem)e.ItemInfo.Item))
                {
                    case StatusDistribuicaoOrdem.ParcialmenteDistribuida:
                        e.Style = BaseRow.GridRowBusiness04; // verde
                        break;

                    case StatusDistribuicaoOrdem.Distribuida:
                        e.Style = BaseRow.GridRowBusiness02; // azul
                        break;

                    default:
                        e.Style = BaseRow.GridRowBusiness06; // vermelho
                        break;
                }
            } // if (e.OriginalSource is BaseRow)}
        }

        /// <summary>
        /// - Altera cor da linha para:
        ///    AZUL
        ///        Se a quantidade digitada é igual à quantidade casada 
        ///        OU 
        ///        o percentual digitado é igual a 100% (cem por cento), 
        ///        para o pregão indicado no campo Data Pregão.
        ///    VERMELHO
        ///        Se ordem não está distribuída, ou seja, a quantidade digitada 
        ///        ou o percentual digitado é igual a 0 (zero), 
        ///        para o pregão indicado no campo Data Pregão.
        ///    VERDE
        ///        Se a quantidade digitada é maior que 0 (zero) e menor que 
        ///        a quantidade casada 
        ///        OU
        ///        o percentual digitado é maior que 0 (zero) e menor que 
        ///        100% (cem por cento), para o pregão indicado no campo 
        ///        Data Pregão.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void lotesDataGridTodas_ApplyingStyle(object sender, ApplyStyleEventArgs e)
        {
            if (e.ItemInfo.Item == null)
                return;

            if (e.OriginalSource is BaseRow)
            {
                switch (Presenter.VerificarDistribuicaoOrdem((Model.Ordem)e.ItemInfo.Item))
                {
                    case StatusDistribuicaoOrdem.ParcialmenteDistribuida:
                        e.Style = BaseRow.GridRowBusiness04; // verde
                        break;

                    case StatusDistribuicaoOrdem.Distribuida:
                        e.Style = BaseRow.GridRowBusiness02; // azul
                        break;

                    default:
                        e.Style = BaseRow.GridRowBusiness06; // vermelho
                        break;
                }
            }// if (e.OriginalSource is BaseRow)}
        }

        /// <summary>
        /// Altera cor da linha do grid de ordens para:
        ///     AZUL: Significa que a ordem já está distribuída
        ///     VERMELHO: Significa ordem não distribuída.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ordensDataGrid_ApplyingStyle(object sender, ApplyStyleEventArgs e)
        {
            if (e.ItemInfo.Item == null)
                return;

            if (e.OriginalSource is BaseRow)
            {
                Model.Ordem ordem = (Model.Ordem)e.ItemInfo.Item;
                switch (ordem.IndicadorDistribuicao)
                {
                    case "N":
                        e.Style = BaseRow.GridRowBusiness06; // vermelho
                        break;

                    default:
                        e.Style = BaseRow.GridRowBusiness02; // azul
                        break;
                }
            } // if (e.OriginalSource is BaseRow)}            
        }

        private void popup_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
            // desabilita a janela principal toda vez que o Pop-Up for exibido
            this.IsEnabled = !((SinacorPopup)sender).IsVisible;
        }

        private void ctxMnuDistribuir_Click(object sender, RoutedEventArgs e)
        {

            SinacorTabItem tabSelecionada = (SinacorTabItem)tabGrupoLotes.SelectedItem;
            SinacorDataGrid gridOrigem;

            if (tabSelecionada == tabDiscricionarias)
            {
                gridOrigem = lotesDataGridDiscricionarias;
            }
            else if (tabSelecionada == tabNaoDiscricionarias)
            {
                gridOrigem = lotesDataGridNaoDiscricionarias;
            }
            else //tabTodas
            {
                gridOrigem = lotesDataGridTodas;
            }
            

            this.Habilitar(false);
            try
            {
               
                this.EnviarLotesDigitacao(gridOrigem);
            }
            catch (Exception ex)
            {
                InformarErro("Bovespa.Ordens.ExceptionMessage.ErroEnviarLoteDigitacao");
            }
            finally
            {
                this.Habilitar(true);
            }

            //ModelCollection<Model.Ordem> lotes = GetGridSelectedItems(this.lotesDataGrid);

            ////VAI RECEBER O TIPO DE AGRUPAMENTO UTILIZADO PARA A CONSULTA DOS LOTES PARA PASSAR PARA A TELA DE DIGITAÇÃO
            //Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao tipoAgrupamentoOrdens;

            ////SE A SELEÇÃO FOR MÚLTIPLA, VERIFICAR O TIPO DE AGRUPAMENTO. NÃO PODE SER OPERAÇÕES POP OU ADMINISTRADO CONCORRENTE
            //if (lotes.Count > 1 && (rdbAdmConc.IsChecked == true || rdbOpPOP.IsChecked == true))
            //{
            //    this.InformarErro("Bovespa.Ordens.Message.DistribuicaoOrdemLote.SelecaoMultiplaIlegal");
            //    return;
            //}

            ////PRIMEIRO VALIDO O PRIMEIRO LOTE DA SELEÇÃO (NO LOOP ABAIXO EU SÓ COMPARO OS SUBSEQUENTES COM O PRIMEIRO
            //if (lotes.Count > 0 && lotes[0].QuantidadeDigitada > 0)
            //{
            //    this.InformarErro("Bovespa.Ordens.Message.SomenteOrdensNaoDistribuidas");
            //}

            ////O LOOP ABAIXO SÓ SERÁ EXECUTADO CASO HAJAM MAIS DE UMA LINHA SELECIONADA
            //for (int i = 1; i < lotes.Count; i++)
            //{
            //    if (lotes[i].QuantidadeDigitada > 0)
            //    {
            //        this.InformarErro("Bovespa.Ordens.Message.SomenteOrdensNaoDistribuidas");
            //        return;
            //    }

            //    if (lotes[i].ApelidoCliente != lotes[0].ApelidoCliente || lotes[i].Discricionaria != lotes[0].Discricionaria || lotes[i].CodigoNegocio != lotes[0].CodigoNegocio)
            //    {
            //        this.InformarErro("Bovespa.Ordens.Message.MultiplosLotesDadosIguais");
            //        return;
            //    }
            //}

            //SinacorMessageBox.Show("Operação válida");

            //Model.Parameter.TipoAgrupamentoLote agrupamento = Model.Parameter.TipoAgrupamentoLote.SemAgrupamento;

            //if ((bool)rdbPadrao.IsChecked)
            //    agrupamento = Sinacor.UI.Bovespa.Ordens.Model.Parameter.TipoAgrupamentoLote.Padrao;
            //else if ((bool)rdbOperador.IsChecked)
            //    agrupamento = Sinacor.UI.Bovespa.Ordens.Model.Parameter.TipoAgrupamentoLote.Operador;


            // bool? discricionaria = null;

            //if ((bool)rdbDiscr.IsChecked)
            //    discricionaria = true;
            //else if ((bool)rdbNaoDiscr.IsChecked)
            //    discricionaria = false;


            //foreach (Model.Ordem lote in lotes)
            //{
            //    //Se o número do lote for 0, criar um novo lote.
            //    if (lote.NumeroConjunto == null || lote.NumeroConjunto == 0)
            //    {
            //        ModelCollection<Model.Ordem> ordensLote = Presenter.ConsultarOrdensLote(lote, (Model.Calendario)cmbData.SelectedItem, agrupamento, discricionaria);

            //        lote.NumeroConjunto = Presenter.CriarLoteOrdem(ordensLote);
            //        //lote.NumeroConjunto = CriarNovoLote(ordensLote);
            //    }
            //}

            ////VERIFICO QUAL O AGRUPAMENTO (DIFERENTE DA VERIFICAÇÃO ACIMA QUE SÓ LEVA EM CONTA SE AS ORDENS ESTÃO AGRUPADAS E NÃO CONTEMPLA ADM E POP)
            //if (rdbPadrao.IsChecked == true)
            //{
            //    tipoAgrupamentoOrdens = TipoOrdemDistribuicao.Padrao;
            //}
            //else if (rdbOperador.IsChecked == true)
            //{
            //    tipoAgrupamentoOrdens = TipoOrdemDistribuicao.Operador;
            //}
            //else if (rdbOrdem.IsChecked == true)
            //{
            //    tipoAgrupamentoOrdens = TipoOrdemDistribuicao.Ordens;
            //}
            //else if (rdbAdmConc.IsChecked == true)
            //{
            //    tipoAgrupamentoOrdens = TipoOrdemDistribuicao.AdministradoConcorrente;
            //}
            //else if (rdbOpPOP.IsChecked == true)
            //{
            //    tipoAgrupamentoOrdens = TipoOrdemDistribuicao.POP;
            //}

            ///*
            ////Chamar a tela de distribuição de ordens
            //this.Habilitar(false);
            //View.SmartClient.DistribuicaoOrdemDigitacao distribuicaoDigitacao = new View.SmartClient.DistribuicaoOrdemDigitacao();
            //distribuicaoDigitacao.Owner = this;
            //distribuicaoDigitacao.SetMenuHeader("Bovespa.Clientes.Label.PesquisaClientesMenuHeader");

            //distribuicaoDigitacao.CarregaOrdens(lotes, ((Model.Calendario)cmbData.SelectedItem).DataPregao);

            ////distribuicaoDigitacao.CarregaOrdens(lotes, ((Model.Calendario)cmbData.SelectedItem).DataPregao, tipoAgrupamentoOrdens);

            //this.Habilitar(true);
            //distribuicaoDigitacao.ShowDialog();
            //*/
        }

        private void ctxMnuCancelar_Click(object sender, RoutedEventArgs e)
        {
            SinacorTabItem tabSelecionada = (SinacorTabItem)tabGrupoLotes.SelectedItem;
            SinacorDataGrid gridOrigem;

            if (tabSelecionada == tabDiscricionarias)
            {
                gridOrigem = lotesDataGridDiscricionarias;
            }
            else if (tabSelecionada == tabNaoDiscricionarias)
            {
                gridOrigem = lotesDataGridNaoDiscricionarias;
            }
            else //tabTodas
            {
                gridOrigem = lotesDataGridTodas;
            }

            ModelCollection<Model.Ordem> lotes = GetGridSelectedItems(gridOrigem);
            ModelCollection<Model.Parameter.CancelarOrdemDistribuidaRequest> parameters = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Parameter.CancelarOrdemDistribuidaRequest>();

            //ESTA LINHA ESTÁ AQUI SÓ PRA SEGURANÇA. PROVAVELMENTE NÃO SERÁ NULL NUNCA
            if (lotes == null) return;

            foreach (Model.Ordem itemLote in lotes)
            {
                Model.Parameter.CancelarOrdemDistribuidaRequest pCancelarOrdemDistribuida = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.CancelarOrdemDistribuidaRequest();

                pCancelarOrdemDistribuida.CodigoFilhote = 0;
                pCancelarOrdemDistribuida.DataOrdem = ((Model.Calendario)cmbData.SelectedItem).DataPregao; //ONDE EU CONSIGO DATA ORDEM?
                pCancelarOrdemDistribuida.DataPregao = ((Model.Calendario)cmbData.SelectedItem).DataPregao;
                pCancelarOrdemDistribuida.NumeroConjunto = (int)itemLote.NumeroConjunto;
                pCancelarOrdemDistribuida.NumeroOrdem = (int)itemLote.NumeroOrdem;
                pCancelarOrdemDistribuida.NumeroOrdemSubSequencia = 0;
                pCancelarOrdemDistribuida.TipoCancelamento = "T";
                parameters.Add(pCancelarOrdemDistribuida);
            }

            this.ClearServiceErrors();
            Presenter.CancelarOrdemDistribuida(parameters);

            AtualizaGrids(true);
        }

        #endregion

        #region Métodos

        #endregion

        #region IDistribuicaoOrdemLoteView

        /// <summary>
        /// Carrega o combo Data
        /// </summary>
        public void ApresentarDataCalendario()
        {
            cmbData.UpdateTarget(SinacorComboBox.ItemsSourceProperty);
        }

        /// <summary>
        /// Carrega o grid de Lotes Vinculados
        /// </summary>
        public void ApresentarLoteVinculado()
        {
            //precoMedioDataGrid.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);

            precoMedioDiscricionariasDataGrid.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);
            precoMedioNaoDiscricionariasDataGrid.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);
            precoMedioTodasDataGrid.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);
        }

        /// <summary>
        /// Carrega a lista de contexto(botao direito) 
        /// para mover a(s) ordem(ns) de lote.
        /// </summary>
        public void ApresentarLoteVinculadoContextMenu()
        {
            //lotesListBox.UpdateTarget(SinacorListBox.ItemsSourceProperty);

            lotesListBoxDiscricionarias.UpdateTarget(SinacorListBox.ItemsSourceProperty);
            lotesListBoxNaoDiscricionarias.UpdateTarget(SinacorListBox.ItemsSourceProperty);
            lotesListBoxTodas.UpdateTarget(SinacorListBox.ItemsSourceProperty);            
        }

        /// <summary>
        /// Carrega o grid de Lotes
        /// </summary>
        public void ApresentarOrdemDistribuicao()
        {
            //lotesDataGrid.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);
            lotesDataGridTodas.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);
            lotesDataGridDiscricionarias.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);
            lotesDataGridNaoDiscricionarias.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);
        }

        /// <summary>
        /// Carrega o grid de Ordens Atribuidas ao Lote
        /// </summary>
        public void ApresentarOrdemDistribuicaoOrdem()
        {
            //ordensDataGrid.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);

            ordensTodasDataGrid.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);
            ordensNaoDiscricionariasDataGrid.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);
            ordensDiscricionariasDataGrid.UpdateTarget(SinacorDataGrid.ItemsSourceProperty);
        }

        /// <summary>
        /// Apresenta ou não mesagem de ordem não casada
        /// </summary>
        public void ApresentarMensagemOrdem(bool mostramsg)
        {

            if ((SinacorTabItem)tabGrupoLotes.Items.CurrentItem == tabDiscricionarias)
                lblMensagem1.Visibility = (mostramsg) ? Visibility.Visible : Visibility.Collapsed;
            else if ((SinacorTabItem)tabGrupoLotes.Items.CurrentItem == tabNaoDiscricionarias)
                lblMensagem2.Visibility = (mostramsg) ? Visibility.Visible : Visibility.Collapsed;
            else
                lblMensagem3.Visibility = (mostramsg) ? Visibility.Visible : Visibility.Collapsed;

        }

        public void Habilitar(bool habilitado)
        {
            MostrarPopUp(false);

            if (habilitado)
                this.HideUserWaitingProcess();
            else
                this.ShowUserWaitingProcess();
        }

        public void Informar(string resourceString)
        {
            Habilitar(true);
            SinacorMessageBox.Show((string)ResourceProviderManager.GetResourceProvider().TryGetResource(resourceString), SinacorMessageBoxImage.Information);
        }

        public void InformarErro(string resourceString)
        {
            Habilitar(true);
            SinacorMessageBox.Show((string)ResourceProviderManager.GetResourceProvider().TryGetResource(resourceString), SinacorMessageBoxImage.Error);
        }

        // selecionar no grid de lotes uma linha contendo o lote determinado
        //este método não está sendo usado. Motivo pelo qual não será adaptado para o padrão das tabs
        public bool SelecionarLote(int numeroLote)
        {
            //if (numeroLote == 0 || lotesDataGrid.Items == null)
            //    return false;

            //foreach (Model.Ordem ordemModel in lotesDataGrid.Items)
            //{
            //    if (ordemModel.NumeroConjunto != null && ordemModel.NumeroConjunto == numeroLote)
            //    {
            //        lotesDataGrid.IsSynchronizedWithCurrentItem = true;
            //        lotesDataGrid.SelectedItem = ordemModel;
            //        this.ApresentarOrdemDistribuicao();
            //        lotesDataGrid.IsSynchronizedWithCurrentItem = false;
            //        return true;
            //    }
            //}

            return false;
        }

        public void ConfirmarAlteracaoDataPregao()
        {
            if ((SinacorMessageBoxResult)SinacorMessageBox.Show((string)ResourceProviderManager.GetResourceProvider().TryGetResource("Bovespa.Ordens.Message.ConfirmarAlteracaoDataPregao"), SinacorMessageBoxButton.YesNo, SinacorMessageBoxImage.Question) == SinacorMessageBoxResult.Yes)
                AlterarDataPregaoAtual();
            else
            {
                rdbPadrao.IsChecked = true;
                this.tipoAgrupamento = _TipoAgrupamento.Padrao;
            }
        }

        /// <summary>
        /// Habilita os controles de tipo de consulta conforme permissão do usuário.
        /// 09/12/2008
        /// Valdenir Vanalli Filho
        /// </summary>
        /// <param name="TipoPermisao">String contendo o tipo de permissão a que o usuário tem acesso</param>

        public void AlterarDataPregaoAtual()
        {
            int i, iTemp = 0;
            DateTime dataAtual = ((Model.Calendario)cmbData.SelectedItem).DataPregao;

            for (i = 0; i < cmbData.Items.Count; i++)
            {
                if (((Model.Calendario)cmbData.Items[i]).DataPregao > dataAtual)
                {
                    iTemp = i;
                    dataAtual = ((Model.Calendario)cmbData.Items[i]).DataPregao;
                }
            }

            //ESTE IF SÓ EXISTE PORQUE A DATA DA MASSA DE TESTE NÃO É ATUAL
            if (iTemp > 0)
                cmbData.SelectedIndex = iTemp;
        }

        public void InformarCancelamentoEfetuado()
        {
            this.Informar("Bovespa.Ordens.Message.CancelamentoOrdemDistSucess");
        }

        public void InformaUsuarioNaoPermissao()
        {
            this.InformarErro("Bovespa.Acesso.ExceptionMessage.PERMISSAOACESSO");
            //SinacorMessageBox.Show("Usuário sem permissão de acesso à funcionalidade.", SinacorMessageBoxButton.Ok, SinacorMessageBoxImage.Error);
            this.Close();
        }

        #endregion

        // Resource String que possui formatacao da mensagem de "Novo Lote Criado"
        private string novoLoteResourceString = (string)ResourceProviderManager.GetResourceProvider().TryGetResource("Bovespa.Ordens.Message.LoteCriado");

        public DistribuicaoOrdemLote()
        {
            this.InitializeComponent();
            lotesDataGridDiscricionarias.NewItemType = typeof(Model.Ordem);
            lotesDataGridNaoDiscricionarias.NewItemType = typeof(Model.Ordem);
            lotesDataGridTodas.NewItemType = typeof(Model.Ordem);
            ordensDiscricionariasDataGrid.NewItemType = typeof(Model.Ordem);
            precoMedioDiscricionariasDataGrid.NewItemType = typeof(Model.LoteOrdem);
            precoMedioNaoDiscricionariasDataGrid.NewItemType = typeof(Model.LoteOrdem);
            ordensTodasDataGrid.NewItemType = typeof(Model.Ordem);
            precoMedioTodasDataGrid.NewItemType = typeof(Model.LoteOrdem);
            ordensNaoDiscricionariasDataGrid.NewItemType = typeof(Model.Ordem); 

            CriarPopUpLotes();

            this.Presenter = new DistribuicaoOrdemLotePresenter(this);
            this.DataContext = this.Presenter;
            this.AfterInitialize += new RoutedEventHandler(DistribuicaoOrdemLote_AfterInitialize);

            //VERIFICO SE O USUÁRIO TEM PERMISSÃO PARA CANCELAMENTO DE DISTRIBUIÇÃO DE ORDENS
            Model.Parameter.VerificarAcessoFuncaoRequest objRequest = new Model.Parameter.VerificarAcessoFuncaoRequest();
            objRequest.Funcao = "CDIS";
            this._acessoCancelamentoDistribuicao = Presenter.VerificaPermissaoUsuario(objRequest);
        }

        private void CriarPopUpLotes()
        {
            //popup.Content = FindResource("lotesPopUpTemplate");
            //popup.Header = "Lotes";
            ////popup.PlacementTarget = ordensDataGrid;
            //popup.PlacementTarget = ordensDiscricionariasDataGrid;
            //popup.Placement = System.Windows.Controls.Primitives.PlacementMode.Center;
            //popup.StaysOpen = true;  // Pop-Up nao reabre se esta linha estiver ausente. Favor manter até segunda ordem.
            ////popup.LostFocus += new RoutedEventHandler(popup_LostFocus);  
            //popup.IsVisibleChanged += new DependencyPropertyChangedEventHandler(popup_IsVisibleChanged);

            //lotesListBox = (SinacorListBox)(((Grid)popup.Content)).Children[0];

            //Popup Discricionárias
            popUpDiscricionarias.Content = FindResource("lotesPopUpDiscricionariasTemplate");
            popUpDiscricionarias.Header = "Lotes";
            //popup.PlacementTarget = ordensDataGrid;
            popUpDiscricionarias.PlacementTarget = ordensDiscricionariasDataGrid;
            popUpDiscricionarias.Placement = System.Windows.Controls.Primitives.PlacementMode.Center;
            popUpDiscricionarias.StaysOpen = true;  // Pop-Up nao reabre se esta linha estiver ausente. Favor manter até segunda ordem.
            //popup.LostFocus += new RoutedEventHandler(popup_LostFocus);  
            popUpDiscricionarias.IsVisibleChanged += new DependencyPropertyChangedEventHandler(popup_IsVisibleChanged);

            lotesListBoxDiscricionarias = (SinacorListBox)(((Grid)popUpDiscricionarias.Content)).Children[0];


            //Popup Não-Discricionárias
            popUpNaoDiscricionarias.Content = FindResource("lotesPopUpNaoDiscricionariasTemplate");
            popUpNaoDiscricionarias.Header = "Lotes";
            //popup.PlacementTarget = ordensDataGrid;
            popUpNaoDiscricionarias.PlacementTarget = ordensNaoDiscricionariasDataGrid;
            popUpNaoDiscricionarias.Placement = System.Windows.Controls.Primitives.PlacementMode.Center;
            popUpNaoDiscricionarias.StaysOpen = true;  // Pop-Up nao reabre se esta linha estiver ausente. Favor manter até segunda ordem.
            //popup.LostFocus += new RoutedEventHandler(popup_LostFocus);  
            popUpNaoDiscricionarias.IsVisibleChanged += new DependencyPropertyChangedEventHandler(popup_IsVisibleChanged);

            lotesListBoxNaoDiscricionarias = (SinacorListBox)(((Grid)popUpNaoDiscricionarias.Content)).Children[0];

            //Popup Todas
            popUpTodas.Content = FindResource("lotesPopUpTodasTemplate");
            popUpTodas.Header = "Lotes";
            //popup.PlacementTarget = ordensDataGrid;
            popUpTodas.PlacementTarget = ordensTodasDataGrid;
            popUpTodas.Placement = System.Windows.Controls.Primitives.PlacementMode.Center;
            popUpTodas.StaysOpen = true;  // Pop-Up nao reabre se esta linha estiver ausente. Favor manter até segunda ordem.
            //popup.LostFocus += new RoutedEventHandler(popup_LostFocus);  
            popUpTodas.IsVisibleChanged += new DependencyPropertyChangedEventHandler(popup_IsVisibleChanged);

            lotesListBoxTodas = (SinacorListBox)(((Grid)popUpTodas.Content)).Children[0];
        }

        private void AtualizarBinding()
        {
            if ((bool)rdbPadrao.IsChecked)
                Presenter.OrdemDistribuicaoModel.OrdemDistribuicaoGrupo = Model.Enum.OrdemDistribuicaoGrupo.Padrao;
            else if ((bool)rdbOperador.IsChecked)
                Presenter.OrdemDistribuicaoModel.OrdemDistribuicaoGrupo = Model.Enum.OrdemDistribuicaoGrupo.Operador;
            else if ((bool)rdbOrdem.IsChecked)
                Presenter.OrdemDistribuicaoModel.OrdemDistribuicaoGrupo = Model.Enum.OrdemDistribuicaoGrupo.Ordem;
            else if ((bool)rdbAdmConc.IsChecked)
                Presenter.OrdemDistribuicaoModel.OrdemDistribuicaoGrupo = Model.Enum.OrdemDistribuicaoGrupo.AdministradoConcorrente;
            else if ((bool)rdbOpPOP.IsChecked)
                Presenter.OrdemDistribuicaoModel.OrdemDistribuicaoGrupo = Model.Enum.OrdemDistribuicaoGrupo.POP;
        }

        public void AtualizarGridOrdens(SinacorDataGrid lotesDataGrid)
        {
            //SinacorDataGrid lotesDataGrid = (SinacorDataGrid)sender;

            if (lotesDataGrid.SelectedItem == null || lotesDataGrid.SelectedItems.Count != 1)

                if (lotesDataGrid.SelectedItem == null) //A VERIFICAÇÃO DE MAIS DE UM LOTE NÃO É MAIS NECESSÁRIA, SERÁ IMPLEMENTADO ESCOLHA DE MÚLTIPLOS LOTES
                    return;

            bool? discricionaria = null;

            if ((SinacorTabItem)tabGrupoLotes.Items.CurrentItem == tabDiscricionarias)
                discricionaria = true;
            else if ((SinacorTabItem)tabGrupoLotes.Items.CurrentItem == tabNaoDiscricionarias)
                discricionaria = false;

            Model.Parameter.TipoAgrupamentoLote agrupamento = Model.Parameter.TipoAgrupamentoLote.SemAgrupamento;

            if ((bool)rdbPadrao.IsChecked)
                agrupamento = Sinacor.UI.Bovespa.Ordens.Model.Parameter.TipoAgrupamentoLote.Padrao;
            else if ((bool)rdbOperador.IsChecked)
                agrupamento = Sinacor.UI.Bovespa.Ordens.Model.Parameter.TipoAgrupamentoLote.Operador;

            if (lotesDataGrid == lotesDataGridDiscricionarias)
            {
                Presenter.ConsultarOrdensDistribuicaoDiscricionarias(
                    (Model.Ordem)lotesDataGrid.SelectedItem,
                    (Model.Calendario)cmbData.SelectedItem,
                    agrupamento,
                    discricionaria);
            }
            else if (lotesDataGrid == lotesDataGridNaoDiscricionarias)
            {
                Presenter.ConsultarOrdensDistribuicaoNaoDiscricionarias(
                    (Model.Ordem)lotesDataGrid.SelectedItem,
                    (Model.Calendario)cmbData.SelectedItem,
                    agrupamento,
                    discricionaria);
            }
            else if (lotesDataGrid == lotesDataGridTodas)
            {
                Presenter.ConsultarOrdensDistribuicaoTodas(
                    (Model.Ordem)lotesDataGrid.SelectedItem,
                    (Model.Calendario)cmbData.SelectedItem,
                    agrupamento,
                    discricionaria);
            }

            //ordensExpander.IsExpanded = (Presenter.OrdemDistribuicaoOrdemModelCollection != null && Presenter.OrdemDistribuicaoOrdemModelCollection.Count > 0);

            ordensExpanderDiscricionarias.IsExpanded = (Presenter.OrdensDiscricionariasModelCollection != null && Presenter.OrdensDiscricionariasModelCollection.Count > 0);
            ordensExpanderNaoDiscricionarias.IsExpanded = (Presenter.OrdensNaoDiscricionariasModelCollection != null && Presenter.OrdensNaoDiscricionariasModelCollection.Count > 0);
            ordensExpanderTodas.IsExpanded = (Presenter.OrdensTodasModelCollection != null && Presenter.OrdensTodasModelCollection.Count > 0);

            if (!ordensExpanderDiscricionarias.IsExpanded && !ordensExpanderNaoDiscricionarias.IsExpanded && !ordensExpanderTodas.IsExpanded)
            {
                Informar("Bovespa.Ordens.Message.LoteSemOrdens");
            }
        }

        private void PesquisarOrdens()
        {
            if (cmbData.SelectedItem == null)
            {
                InformarErro("Bovespa.Ordens.Message.DataPregaoInvalida");
                return;
            }

            this.Habilitar(false);
            AtualizarBinding();
            this.Presenter.Limpar();
            this.Presenter.ConsultarOrdemDistribuicao(Presenter.OrdemDistribuicaoModel, txtAtivo.Text, txtCliente.Text);
            //this.ordensExpander.IsExpanded = false;
            this.ordensExpanderDiscricionarias.IsExpanded = false;
            this.ordensExpanderNaoDiscricionarias.IsExpanded = false;
            this.ordensExpanderTodas.IsExpanded = false;

            this.Habilitar(true);
        }

        // verifica se no atual contexto sera´ permitido mostrar o Pop-Up com lista de lotes
        private bool PermitirPopUp()
        {
            //CRIO OBJETOS PARA TORNAR O MÉTODO GENÉRICO ÀS TRÊS TABS
            SinacorTabItem tabSelecionada = (SinacorTabItem)tabGrupoLotes.SelectedItem;
            SinacorDataGrid ordensDataGrid;
            ModelCollection<Model.LoteOrdem> TrocarLoteBoxModelCollection;

            //ATRIBUO OS ELEMENTOS DA TELA AOS OBJETOS DESTE MÉTODO, CONFORME A ABA SELECIONADA
            if (tabSelecionada == tabDiscricionarias)
            {
                ordensDataGrid = ordensDiscricionariasDataGrid;
                TrocarLoteBoxModelCollection = Presenter.TrocarLoteBoxDiscricionariasModelCollection;
            }
            else if (tabSelecionada == tabNaoDiscricionarias)
            {
                ordensDataGrid = ordensNaoDiscricionariasDataGrid;
                TrocarLoteBoxModelCollection = Presenter.TrocarLoteBoxNaoDiscricionariasModelCollection;
            }
            else //tabTodas
            {
                ordensDataGrid = ordensTodasDataGrid;
                TrocarLoteBoxModelCollection = Presenter.TrocarLoteBoxTodasModelCollection;
            }

            //SE NÃO HOUVER NENHUM ITEM SELECIONADO NA GRID DE ORDENS, RETORNO FALSO
            if (ordensDataGrid.SelectedItems == null || ordensDataGrid.SelectedItems.Count == 0)
            {
                return false;
            }

            //SE HOUVER ALGUM ITEM SELECIONADO QUE TENHA SIDO DISTRIBUIDO, RETORNO FALSO
            foreach (Model.Ordem ordem in ordensDataGrid.SelectedItems)
            {
                if (ordem.IndicadorDistribuicao != "N")
                    return false;
            }

            return
                TrocarLoteBoxModelCollection != null &&
                TrocarLoteBoxModelCollection.Count != 0 &&
                !(bool)rdbAdmConc.IsChecked &&
                !(bool)rdbOpPOP.IsChecked
            ;
        }

        // mostra ou esconde Pop-Up com lista de lotes
        private void MostrarPopUp(bool abrir)
        {
            SinacorTabItem tabSelecionada = (SinacorTabItem)tabGrupoLotes.SelectedItem;

            if (tabSelecionada == tabDiscricionarias)
            {
                if (popUpDiscricionarias != null)
                {
                    popUpDiscricionarias.IsOpen = (abrir && PermitirPopUp());
                }
            }
            else if (tabSelecionada == tabNaoDiscricionarias)
            {
                if (popUpNaoDiscricionarias != null)
                {
                    popUpNaoDiscricionarias.IsOpen = (abrir && PermitirPopUp());
                }
            }
            else //tabTodas
            {
                if (popUpTodas != null)
                {
                    popUpTodas.IsOpen = (abrir && PermitirPopUp());
                }
            }
        }

        // permitir selecionar apenas um item por vez em um dado grid
        private void SingleSelect(object sender)
        {
            SinacorDataGrid grid = (SinacorDataGrid)sender;

            // se nao houve itens selecionados, nao faz nada
            if (grid.SelectedItems == null || grid.SelectedItems.Count == 0)
                return;

            // se houver mais de um item selecionado na lista, prevalecera´ o ultimo
            // e os demais serao descartados
            if (grid.SelectedItems.Count > 1)
            {
                grid.SelectedItem = grid.SelectedItems[grid.SelectedItems.Count - 1];
            }
        }

        private int CriarNovoLote(ModelCollection<Model.Ordem> ordens)
        {
            int numeroNovoLote = 0;

            if (Presenter.OrdemDistribuicaoOrdemModelCollection != null && Presenter.OrdemDistribuicaoOrdemModelCollection.Count > 0)
            {
                numeroNovoLote = Presenter.CriarLoteOrdem(ordens);
            }

            return numeroNovoLote;
        }

        private bool PermitirCriarLote()
        {
            SinacorTabItem tabSelecionada = (SinacorTabItem)tabGrupoLotes.SelectedItem;
            SinacorDataGrid ordensDataGrid;
            SinacorDataGrid lotesDataGrid;

            if (tabSelecionada == tabDiscricionarias)
            {
                ordensDataGrid = ordensDiscricionariasDataGrid;
                lotesDataGrid = lotesDataGridDiscricionarias;
            }
            else if (tabSelecionada == tabNaoDiscricionarias)
            {
                ordensDataGrid = ordensNaoDiscricionariasDataGrid;
                lotesDataGrid = lotesDataGridNaoDiscricionarias;
            }
            else //tabTodas
            {
                ordensDataGrid = ordensTodasDataGrid;
                lotesDataGrid = lotesDataGridTodas;
            }

            if (ordensDataGrid.SelectedItems == null || ordensDataGrid.SelectedItems.Count == 0)
            {
                return false;
            }

            //int NumeroLoteAtual = (int)((Model.Ordem)ordensDataGrid.SelectedItems[0]).NumeroConjunto;

            //if (NumeroLoteAtual == 0)
            //    return true;

            //foreach (Model.Ordem itemLote in lotesDataGrid.Items)
            //{
            //    if (itemLote.NumeroConjunto == NumeroLoteAtual)
            //    {
            //        if (Presenter.VerificarDistribuicaoOrdem(itemLote) == StatusDistribuicaoOrdem.Distribuida)
            //            return false;
            //    }
            //}

            foreach (Model.Ordem ordem in ordensDataGrid.SelectedItems)
            {
                if (ordem.IndicadorDistribuicao != "N")
                    return false;
            }
            
            return
                ordensDataGrid.SelectedItems != null &&
                ordensDataGrid.SelectedItems.Count > 0

            ;
        }

        // transforma itens que estiverem selecionados em um grid para ModelCollection
        private ModelCollection<Model.Ordem> GetGridSelectedItems(SinacorDataGrid grid)
        {
            if (grid.SelectedItems == null || grid.SelectedItems.Count < 1)
                return null;

            ModelCollection<Model.Ordem> ordemModelCollection = new ModelCollection<Model.Ordem>();

            foreach (Model.Ordem ordem in grid.SelectedItems)
            {
                ordemModelCollection.Add(ordem);
            }

            return ordemModelCollection;
        }

        public Model.Enum.TipoOrdemDistribuicao VerificarTipoOrdemDistribuicao()
        {
            Model.Enum.TipoOrdemDistribuicao enumTipoOrdemdistribuicao = new Model.Enum.TipoOrdemDistribuicao();

            if (rdbPadrao.IsChecked == true)
                enumTipoOrdemdistribuicao = Model.Enum.TipoOrdemDistribuicao.Padrao;
            else if (rdbOperador.IsChecked == true)
                enumTipoOrdemdistribuicao = Model.Enum.TipoOrdemDistribuicao.Operador;
            else if (rdbOrdem.IsChecked == true)
                enumTipoOrdemdistribuicao = Model.Enum.TipoOrdemDistribuicao.Ordens;
            else if (rdbAdmConc.IsChecked == true)
                enumTipoOrdemdistribuicao = Model.Enum.TipoOrdemDistribuicao.AdministradoConcorrente;
            else if (rdbOpPOP.IsChecked == true)
                enumTipoOrdemdistribuicao = Model.Enum.TipoOrdemDistribuicao.POP;

            return enumTipoOrdemdistribuicao;

        }

        private void EnviarLotesDigitacao(SinacorDataGrid gridOrigem)
        {
            this.ClearServiceErrors();

            //RECUPERO A LISTA DOS ITENS SELECIONADOS
            ModelCollection<Model.Ordem> lotes = GetGridSelectedItems(gridOrigem);

            //CRIO A VARIÁVEL QUE ARMAZENARÁ O TIPO DE AGRUPAMENTO SELECIONADO
            Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao tipoAgrupamentoOrdens = TipoOrdemDistribuicao.Padrao;

            //SE A SELEÇÃO FOR MÚLTIPLA, VERIFICAR O TIPO DE AGRUPAMENTO. NÃO PODE SER OPERAÇÕES POP OU ADMINISTRADO CONCORRENTE
            if (lotes.Count > 1 && (rdbAdmConc.IsChecked == true || rdbOpPOP.IsChecked == true))
            {
                this.InformarErro("Bovespa.Ordens.Message.DistribuicaoOrdemLote.SelecaoMultiplaIlegal");
                return;
            }

            //PRIMEIRO VALIDO O PRIMEIRO LOTE DA SELEÇÃO (NO LOOP ABAIXO EU SÓ COMPARO OS SUBSEQUENTES COM O PRIMEIRO
            if (lotes.Count > 1 && (lotes[0].QuantidadeDigitada > 0 || lotes[0].PercentualDigitado > 0))
            {
                this.InformarErro("Bovespa.Ordens.Message.SomenteOrdensNaoDistribuidas");
                return;
            }
            if (lotes[0].QuantidadeCasada == null || lotes[0].QuantidadeCasada.Value == 0)
            {
                InformarErro("Bovespa.Ordens.Message.QtdCasadaObrigatoria");
                return;
            }

            //O LOOP ABAIXO SÓ SERÁ EXECUTADO CASO HAJAM MAIS DE UMA LINHA SELECIONADA
            for (int i = 1; i < lotes.Count; i++)
            {
                if (lotes[i].QuantidadeDigitada > 0 || lotes[i].PercentualDigitado > 0)
                {
                    this.InformarErro("Bovespa.Ordens.Message.SomenteOrdensNaoDistribuidas");
                    return;
                }
                if (lotes[i].QuantidadeCasada == null || lotes[i].QuantidadeCasada.Value == 0)
                {
                    InformarErro("Bovespa.Ordens.Message.QtdCasadaObrigatoria");
                    return;
                }
                if (lotes[i].ApelidoCliente != lotes[0].ApelidoCliente || lotes[i].Discricionaria != lotes[0].Discricionaria || lotes[i].CodigoNegocio != lotes[0].CodigoNegocio)
                {
                    this.InformarErro("Bovespa.Ordens.Message.MultiplosLotesDadosIguais");
                    return;
                }
            }

            //ARMAZENO O AGRUPAMENTO SELECIONADO, SEGUNDO O CRITÉRIO DE CRIAÇÃO DE LOTES
            Model.Parameter.TipoAgrupamentoLote agrupamento = Model.Parameter.TipoAgrupamentoLote.SemAgrupamento;

            if ((bool)rdbPadrao.IsChecked)
                agrupamento = Sinacor.UI.Bovespa.Ordens.Model.Parameter.TipoAgrupamentoLote.Padrao;
            else if ((bool)rdbOperador.IsChecked)
                agrupamento = Sinacor.UI.Bovespa.Ordens.Model.Parameter.TipoAgrupamentoLote.Operador;

            //ARMAZENO O STATUS DE DISCRICIONÁRIA DO FORMULÁRIO, TAMBEM PARA CRIAÇÃO DE LOTE
            bool? discricionaria = null;

            if (lotes[0].Discricionaria == "S")
                discricionaria = true;
            else
                discricionaria = false;

            //VERIFICO QUAL O AGRUPAMENTO (DIFERENTE DA VERIFICAÇÃO ACIMA QUE SÓ LEVA EM CONTA SE AS ORDENS ESTÃO AGRUPADAS E NÃO CONTEMPLA ADM E POP)
            //COMENTEI A VERIFICAÇÃO DO AGRUPAMENTO PADRÃO POIS ELE JÁ VEM COM ESTE VALOR
            //if (rdbPadrao.IsChecked == true)
            //{
            //    tipoAgrupamentoOrdens = TipoOrdemDistribuicao.Padrao;
            //}
            //else 
            if (rdbOperador.IsChecked == true)
            {
                tipoAgrupamentoOrdens = TipoOrdemDistribuicao.Operador;
            }
            else if (rdbOrdem.IsChecked == true)
            {
                tipoAgrupamentoOrdens = TipoOrdemDistribuicao.Ordens;
            }
            else if (rdbAdmConc.IsChecked == true)
            {
                tipoAgrupamentoOrdens = TipoOrdemDistribuicao.AdministradoConcorrente;
            }
            else if (rdbOpPOP.IsChecked == true)
            {
                tipoAgrupamentoOrdens = TipoOrdemDistribuicao.POP;
            }

            //CASO A SELEÇÃO NÃO SEJA DE ADMINISTRADO CONCORRENTE OU OPERAÇÕES POP
            if (!(rdbAdmConc.IsChecked == true || rdbOpPOP.IsChecked == true))
            {
                //PERCORRO A SELEÇÃO DA GRID, CRIANDO OS LOTES SE NECESSÁRIO
                foreach (Model.Ordem lote in lotes)
                {
                    //Se numero do conjunto e´ ZERO e UI nao estiver operando por AdminCon ou POP, criar um novo lote.
                    if (lote.NumeroConjunto == null || lote.NumeroConjunto == 0)
                    {
                        ModelCollection<Model.Ordem> ordensLote = Presenter.ConsultarOrdensLote(lote, (Model.Calendario)cmbData.SelectedItem, agrupamento, discricionaria);

                        lote.NumeroConjunto = Presenter.CriarLoteOrdem(ordensLote);

                        //VERIFICO SE A CRIAÇÃO DE LOTES CORREU SEM PROBLEMAS.
                        if (lote.NumeroConjunto == 0)
                        {
                            //InformarErro("Bovespa.Ordens.Message.ErroCriacaoNovoLote");
                            return;
                        }
                    }
                }
            }

            //CRIO A INSTÂNCIA DA JANELA DE DIGITAÇÃO
            View.SmartClient.DistribuicaoOrdemDigitacao distribuicaoDigitacao = new View.SmartClient.DistribuicaoOrdemDigitacao();
            distribuicaoDigitacao.Owner = this;
            distribuicaoDigitacao.SetMenuHeader("Bovespa.Ordens.Label.Distribuicao");

            if (lotes.Count > 1 && this.Presenter.validarLotesDigitacao(lotes))
            {
                InformarErro("Bovespa.Ordens.Message.Erro_Distribuicao_Multiplo_Lote");

            }
            else
            {
                distribuicaoDigitacao.CarregaOrdens(lotes, ((Model.Calendario)cmbData.SelectedItem).DataPregao, tipoAgrupamentoOrdens);

                distribuicaoDigitacao.ShowDialog();

                AtualizaGrids(true);

                //ATUALIZO A TELA COM OS NUMEROS DOS LOTES CRIADOS
                this.ApresentarOrdemDistribuicao();
            }
        }

        public void AtualizaGrids(bool consideraChkBox)
        {
            if ((consideraChkBox && this.chkAtualizarGradeLotes.IsChecked == true) || (!consideraChkBox))
            {
                this.ClearServiceErrors();
                this.PesquisarOrdens();
            }
            if (tabGrupoLotes.SelectedItem == tabDiscricionarias && (Presenter.LotesDiscricionariasModelCollection == null || Presenter.LotesDiscricionariasModelCollection.Count == 0))
                this.Informar("Bovespa.Ordens.Message.PesquisaSemRetorno");

            if (tabGrupoLotes.SelectedItem == tabNaoDiscricionarias && (Presenter.LotesNaoDiscricionariasModelCollection == null || Presenter.LotesNaoDiscricionariasModelCollection.Count == 0))
                this.Informar("Bovespa.Ordens.Message.PesquisaSemRetorno");

            if (tabGrupoLotes.SelectedItem == tabTodas && (Presenter.LotesTodasModelCollection == null || Presenter.LotesTodasModelCollection.Count == 0))
                this.Informar("Bovespa.Ordens.Message.PesquisaSemRetorno");
        }

        private void cmbData_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (cmbData.SelectedItem == null)
            {
                InformarErro("Bovespa.Ordens.Message.DataPregaoInvalida");

                int i, iTemp = 0;
                for (i = 0; i < cmbData.Items.Count; i++)
                {
                    if ((Model.Calendario)cmbData.Items[i] == e.RemovedItems[0])
                    {
                        iTemp = i;
                        break;
                    }
                }                
                cmbData.SelectedIndex = iTemp;
            }
            
        }

        private decimal ObterPrecoMedioLote(SinacorDataGrid lotesDataGrid, int numeroConjunto)
        {
            foreach (Model.Ordem itemLote in lotesDataGrid.Items)
            {
                if (itemLote.NumeroConjunto == numeroConjunto)
                    return (decimal)itemLote.PrecoMedio;
            }
            //NÃO FOI ENCONTRADO NENHUM LOTE COM O NÚMERO FORNECIDO
            return 0;
        }
    }
}
